home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / µSim 1.0.5 / source / SimUtils.c < prev    next >
Encoding:
Text File  |  1995-12-06  |  9.5 KB  |  356 lines  |  [TEXT/CWIE]
  1. /*
  2. Copyright © 1993,1994,1995 Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware:
  5. you may copy, exchange, modify this code.
  6. You may include this code in any kind of application: freeware,
  7. shareware, or commercial, provided that full credits are given.
  8. You may not sell or distribute this code for profit.
  9. */
  10.  
  11. //#pragma load "MacDump"
  12.  
  13. #include    "UtilsSys7.h"
  14. #include    "Conversions.h"
  15. #include    "FabLibResIDs.h"
  16.  
  17. #include    "Globals.h"
  18. #include    "Animation.h"
  19. #include    "ControlStore.h"
  20. #include    "Dump.h"
  21. #include    "Disasm.h"
  22. #include    "Input.h"
  23. #include    "Main.h"
  24. #include    "Preferences.h"
  25. #include    "Registers.h"
  26. #include    "SimUtils.h"
  27.  
  28. #if defined(FabSystem7orlater)
  29.  
  30. #define    LOWSHORTADDR(l)    (((short *)(&l))+1)
  31.  
  32. #pragma segment Main
  33.  
  34.  
  35. /* FromStringToNum: common code for translating a string with a specified
  36. format to a number */
  37.  
  38. void FromStringToNum(ConstStr255Param sourceStr, long *destN, short whichFormat)
  39. {
  40.  
  41. switch( whichFormat ) {
  42.     case kPOP_DEC:    StringToNum(sourceStr, destN);
  43.                     break;
  44.     case kPOP_HEX:    HexStringToShort(sourceStr, LOWSHORTADDR(*destN));
  45.                     break;
  46.     case kPOP_OCT:    OctStringToShort(sourceStr, LOWSHORTADDR(*destN));
  47.                     break;
  48.     case kPOP_BIN:    BinStringToShort(sourceStr, LOWSHORTADDR(*destN));
  49.                     break;
  50.     case kPOP_TEXT:    *(char *)LOWSHORTADDR(*destN) = sourceStr[1];
  51.                     *((char *)LOWSHORTADDR(*destN) + 1) = sourceStr[2];
  52.                     break;
  53.     }
  54. }
  55.  
  56. /* FromNumToString: common code for translating a number into a
  57. string with a specified format */
  58.  
  59. void FromNumToString(Str255 destStr, short sourceN, short whichFormat)
  60. {
  61.  
  62. switch( whichFormat ) {
  63.     case kPOP_DEC:    MyNumToString(sourceN, destStr);
  64.                     break;
  65.     case kPOP_HEX:    ShortToHexString(sourceN, destStr);
  66.                     break;
  67.     case kPOP_OCT:    ShortToOctString(sourceN, destStr);
  68.                     break;
  69.     case kPOP_BIN:    ShortToBinString(sourceN, destStr);
  70.                     break;
  71.     case kPOP_TEXT:    destStr[0] = 2;
  72.                     destStr[1] = *((char *)&sourceN);
  73.                     destStr[2] = *((char *)&sourceN + 1);
  74.                     break;
  75.     }
  76. }
  77.  
  78. /* MyGrowZone: the Grow Zone proc! */
  79.  
  80. pascal long MyGrowZone(Size /*qNeeded*/)
  81. {
  82. //#pragma unused    (qNeeded)
  83.  
  84. #ifndef __SCRIPT__
  85. #define    smSystemScript    -1
  86. #endif
  87.  
  88. ParamBlockRec    myPB;
  89. Str63    tempFName;
  90. EventRecord    dummyEv;
  91. FSSpec    thisFSSpec;
  92. short    state[kNUMOFSTATEPARTS];    /* the registers & editable parts of my machine */
  93. register Handle    dangerousHandle = GZSaveHnd();
  94. register Handle    readyBuffer;
  95. register long    tempA5;
  96. long    thisDirID;
  97. short    thisVRefNum, tmpFRefN;
  98. register OSErr    err;
  99. register Boolean    somethingInTheTrash = false;
  100.  
  101. tempA5 = SetCurrentA5();
  102. InitCursor();
  103. if (gWPtr_Animation)
  104.     if (offScr) {
  105.         if (offScr->portBits.baseAddr)
  106.             DisposePtr(offScr->portBits.baseAddr);
  107.         if (offScr->visRgn && offScr->clipRgn)
  108.             ClosePort(offScr);
  109.         DisposePtr((Ptr)offScr);
  110.         }
  111. if (gWPtr_Animation &&
  112.     gWPtr_Registers &&
  113.     Ctrl_Base &&
  114.     gWPtr_IO &&
  115.     gWPtr_Microprogram_Ed &&
  116.     gWPtr_Dump &&
  117.     dumpVScroll &&
  118.     gWPtr_Disasm &&
  119.     disasmVScroll)
  120.         SavePreferencesFile();
  121. if (gWPtr_Disasm) {
  122.     DisposeWindow(gWPtr_Disasm);
  123.     gWPtr_Disasm = nil;
  124.     }
  125. if (gWPtr_Dump) {
  126.     DisposeWindow(gWPtr_Dump);
  127.     gWPtr_Dump = nil;
  128.     }
  129. if (gWPtr_IO) {
  130.     if (gIODoc.docTE != (TEHandle)dangerousHandle)
  131.         if (gIODoc.docTE) {
  132.             TEDispose(gIODoc.docTE);
  133.             gIODoc.docTE = nil;
  134.             }
  135.     DisposeWindow(gWPtr_IO);
  136.     gWPtr_IO = nil;
  137.     }
  138. if (gWPtr_Registers) {
  139.     DisposeWindow(gWPtr_Registers);
  140.     gWPtr_Registers = nil;
  141.     }
  142. if (gWPtr_Animation) {
  143.     DisposeWindow(gWPtr_Animation);
  144.     gWPtr_Animation = nil;
  145.     }
  146. /* we should have freed some memory */
  147. if (gMMemory) {
  148.     if ((err = FindFolder(kOnSystemDisk, kTemporaryFolderType, kCreateFolder,
  149.                             &thisVRefNum, &thisDirID)) == noErr) {
  150.         MyNumToString(TickCount(), tempFName);
  151.         (void)FSMakeFSSpecCompat(thisVRefNum, thisDirID, tempFName, &thisFSSpec);
  152.         if ((err = FSpCreateCompat(&thisFSSpec, kFCR_MINE, kFTY_RAM,
  153.                             smSystemScript)) == noErr)
  154.             if ((err = FSpOpenDFCompat(&thisFSSpec, fsWrPerm, &tmpFRefN)) == noErr) {
  155.                 myPB.ioParam.ioCompletion = nil;
  156.                 myPB.ioParam.ioBuffer = gMMemory;
  157.                 myPB.ioParam.ioReqCount = kSIZE_RAM;
  158.                 myPB.ioParam.ioPosMode = fsFromStart | kNoCacheMask;
  159.                 myPB.ioParam.ioRefNum = tmpFRefN;
  160.                 myPB.ioParam.ioPosOffset = 0L;
  161.                 (void)PBWriteAsync(&myPB);    // in temporary file
  162.                 while (myPB.ioParam.ioResult > 0) {
  163.                     SystemTask();
  164.                     (void)EventAvail(everyEvent, &dummyEv);
  165.                     }
  166.                 (void)FSClose(tmpFRefN);
  167.                 DisposePtr(gMMemory);
  168.                 gMMemory = nil;
  169.                 if ((err = myPB.ioParam.ioResult) == noErr) {
  170.                     somethingInTheTrash = true;
  171.                     err = AddSTRRes2Doc(&thisFSSpec, kFCR_MINE, kFTY_RAM,
  172.                                         kSTR_ApplicationName, smSystemScript);
  173.                     }
  174.                 }
  175.         MyNumToString(TickCount() + 1, tempFName);
  176.         (void)FSMakeFSSpecCompat(thisVRefNum, thisDirID, tempFName, &thisFSSpec);
  177.         if ((err = FSpCreateCompat(&thisFSSpec, kFCR_MINE, kFTY_REG,
  178.                             smSystemScript)) == noErr)
  179.             if ((err = FSpOpenDFCompat(&thisFSSpec, fsWrPerm, &tmpFRefN)) == noErr) {
  180.                 BlockMoveData((Ptr)&gParts, (Ptr)&state, sizeof(gParts));
  181.                 BlockMoveData((Ptr)&gRegs, (Ptr)(state + kNUMOFPARTS), sizeof(state) - sizeof(gParts));
  182.                 myPB.ioParam.ioCompletion = nil;
  183.                 myPB.ioParam.ioBuffer = (Ptr)&state;
  184.                 myPB.ioParam.ioReqCount = sizeof(state);
  185.                 myPB.ioParam.ioPosMode = fsFromStart | kNoCacheMask;
  186.                 myPB.ioParam.ioRefNum = tmpFRefN;
  187.                 myPB.ioParam.ioPosOffset = 0L;
  188.                 (void)PBWriteAsync(&myPB);    // in temporary file
  189.                 while (myPB.ioParam.ioResult > 0) {
  190.                     SystemTask();
  191.                     (void)EventAvail(everyEvent, &dummyEv);
  192.                     }
  193.                 (void)FSClose(tmpFRefN);
  194.                 if ((err = myPB.ioParam.ioResult) == noErr) {
  195.                     somethingInTheTrash = true;
  196.                     err = AddSTRRes2Doc(&thisFSSpec, kFCR_MINE, kFTY_REG,
  197.                                         kSTR_ApplicationName, smSystemScript);
  198.                     }
  199.                 }
  200.         readyBuffer = PrepareBufferFromList();
  201.         UnloadSeg(PrepareBufferFromList);
  202.         if (readyBuffer) {
  203.             MyNumToString(TickCount() + 2, tempFName);
  204.             (void)FSMakeFSSpecCompat(thisVRefNum, thisDirID, (ConstStr255Param)&tempFName, &thisFSSpec);
  205.             if ((err = FSpCreateCompat(&thisFSSpec, kFCR_MINE, kFTY_CSTORE,
  206.                                 smSystemScript)) == noErr)
  207.                 if ((err = FSpOpenDFCompat(&thisFSSpec, fsWrPerm, &tmpFRefN)) == noErr) {
  208.                     err = WriteMicroprogramData(readyBuffer, &thisFSSpec, kFTY_CSTORE, tmpFRefN,
  209.                                                 smSystemScript);
  210.                     UnloadSeg(WriteMicroprogramData);
  211.                     (void)FSClose(tmpFRefN);
  212.                     if (err == noErr)
  213.                         err = AddSTRRes2Doc(&thisFSSpec, kFCR_MINE, kFTY_CSTORE,
  214.                                             kSTR_ApplicationName, smSystemScript);
  215.                     }
  216.             }
  217.         }
  218.     }
  219. if (gMMemory) {
  220.     DisposePtr(gMMemory);
  221.     gMMemory = nil;
  222.     }
  223. if (somethingInTheTrash)
  224.     (void)StopAlert_UPP(kALRT_MEMTOOFULL, nil);
  225. tempA5 = SetA5(tempA5);
  226. ExitToShell();
  227. }
  228.  
  229. /* SetupVertScrollBar: adjusts the vertical scrollbar to the right border
  230. of the window */
  231.  
  232. void SetupVertScrollBar(WindowPtr wind, ControlHandle scrollB)
  233. {
  234. MoveControl(scrollB, PRCT_R(wind) - kScrollbarAdjust, PRCT_T(wind) - 1);
  235. SizeControl(scrollB, kScrollbarWidth, PRCT_B(wind) - PRCT_T(wind) - 13);
  236. }
  237.  
  238. /* SetupHorzScrollBar: adjusts the horizontal scrollbar to the bottom border
  239. of the window */
  240.  
  241. void SetupHorzScrollBar(WindowPtr wind, ControlHandle scrollB)
  242. {
  243. MoveControl(scrollB, PRCT_L(wind) - 1, PRCT_B(wind) - kScrollbarAdjust);
  244. SizeControl(scrollB, PRCT_R(wind) - PRCT_L(wind) - 13, kScrollbarWidth);
  245. }
  246.  
  247. /* myStdFilterProc: standard filter proc for all alerts & simple dialogs
  248. WITH a cancel button */
  249.  
  250. pascal Boolean myStdFilterProc(DialogPtr theD, EventRecord *thEv, short *iHit)
  251. {
  252. GrafPtr    savePort;
  253. Boolean    retVal;
  254.  
  255. GetPort(&savePort);
  256. SetPort(theD);
  257. switch (thEv->what) {
  258.     case updateEvt:
  259.         if (theD != (DialogPtr)thEv->message) {
  260.             DoUpdate(thEv);
  261.             thEv->what = nullEvent;
  262.             return false;
  263.             }
  264.         break;
  265.     case activateEvt:
  266.         if (thEv->modifiers & activeFlag) {
  267.             (void)SetDialogDefaultItem(theD, ((DialogPeek)theD)->aDefItem);
  268.             (void)SetDialogCancelItem(theD, cancel);
  269.             (void)SetDialogTracksCursor(theD, false);
  270.             }
  271.         if (theD != (DialogPtr)thEv->message) {
  272.             DoActivate(thEv);
  273.             thEv->what = nullEvent;
  274.             return false;
  275.             }
  276.         break;
  277.     }
  278. retVal = StdFilterProc(theD, thEv, iHit);
  279. SetPort(savePort);
  280. return retVal;
  281. }
  282.  
  283. /* myStdFilterProcNoCancel: standard filter proc for all alerts & simple dialogs
  284. WITHOUT a cancel button */
  285.  
  286. pascal Boolean myStdFilterProcNoCancel(DialogPtr theD, EventRecord *thEv, short *iHit)
  287. {
  288. GrafPtr    savePort;
  289. register Boolean    retVal;
  290.  
  291. GetPort(&savePort);
  292. SetPort(theD);
  293. switch (thEv->what) {
  294.     case updateEvt:
  295.         if (theD != (DialogPtr)thEv->message) {
  296.             DoUpdate(thEv);
  297.             thEv->what = nullEvent;
  298.             return false;
  299.             }
  300.         break;
  301.     case activateEvt:
  302.         if (thEv->modifiers & activeFlag) {
  303.             (void)SetDialogDefaultItem(theD, ((DialogPeek)theD)->aDefItem);
  304.             (void)SetDialogTracksCursor(theD, false);
  305.             }
  306.         if (theD != (DialogPtr)thEv->message) {
  307.             DoActivate(thEv);
  308.             thEv->what = nullEvent;
  309.             return false;
  310.             }
  311.         break;
  312.     }
  313. retVal = StdFilterProc(theD, thEv, iHit);
  314. SetPort(savePort);
  315. return(retVal);
  316. }
  317.  
  318. /* general error alert displaying error code */
  319.  
  320. void ErrorAlert(OSErr reason)
  321. {
  322. Str255    tempS;
  323.  
  324. MyNumToString(reason, tempS);
  325. ParamText(tempS, nil, nil, nil);
  326. (void)StopAlert_UPP(kALRT_GENERICERROR, myStdFilterProcNoCancel);
  327. }
  328.  
  329. #pragma segment Rare
  330.  
  331. /* ResetRegisters: sets the main registers to their default values */
  332.  
  333. void ResetRegisters(void)
  334. {
  335. gRegs[kREG_PC] = gPrefs.DefPCValue;
  336. gRegs[kREG_SP] = gPrefs.DefSPValue;
  337. gParts[kP_MPC - kFIRST_PICT] = 0;
  338. }
  339.  
  340. /* ResetMemory: sets some important "System" memory locations */
  341.  
  342. void ResetMemory(void)
  343. {
  344. register Handle IllHandler = Get1Resource(krHandlers, kIllegalHandlerCode);
  345.  
  346. ((short *)gMMemory)[gPrefs.DefSPValue] = kPCExitToShell;
  347. ((short *)gMMemory)[kIllegalVector] = kIllegalHandler;
  348. BlockMoveData(*IllHandler, (Ptr)((short *)gMMemory + kIllegalHandler),
  349.             InlineGetHandleSize(IllHandler));
  350. }
  351.  
  352. #pragma segment Main
  353.  
  354. #endif
  355.  
  356.